/************************************************************
 * Project Name         [Thinking_In_Java]
 * File Name            [FeeRecordSet.java]
 * Creation Date        [10-Jul-2014]
 * 
 * Copyright© ge.y.yang@gmail.com All Rights Reserved
 * 
 * Work hard, play harder, think big and keep fit
 ************************************************************/
package pkg_01_console_app.fee_mgmt;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * 保存所有自费记录的记录集, 并封装了对该结果进行增删改查排序的方法, 支持以迭代器方式返回记录集
 * 
 * @author 不落的太阳(Sean Yang)
 * @version 1.0
 * @since JDK 6
 * 
 */
public class FeeRecordSet {

	public List<Fee> recordSet = new ArrayList<Fee>();

	/**
	 * 设置资费类型集合
	 * 
	 * @param recordSet
	 *            资费类型集合
	 */
	public void setRecordSet(List<Fee> recordSet) {
		this.recordSet = recordSet;
	}

	/**
	 * 向当前记录集插入一条记录. 如果记录集中已经包含该记录, 则插入失败
	 * 
	 * @param fee
	 *            要插入的记录
	 * @return true表示插入成功, false表示插入失败
	 */
	public boolean insert(Fee fee) {
		if (fee == null || recordSet.contains(fee))
			return false;// 如果记录集中已经包含该记录, 返回false 插入失败
		return recordSet.add(fee); // 调用ArrayList中的方法增加
	}

	/**
	 * 从当前记录集查找指定的资费并删除. 如果未找到, 返回false
	 * 
	 * @param fee
	 *            指定的资费
	 * @return true表示删除成功, false表示删除失败
	 */
	public boolean delete(Fee fee) {
		if (!recordSet.contains(fee))
			return false; // 如果记录集中不包含该记录, 返回false 删除失败
		return recordSet.remove(fee); // 调用ArrayList中的方法删除
	}

	/**
	 * 从当前记录集中按id查找指定的资费并删除. 如果未找到, 返回false
	 * 
	 * @param id
	 *            指定的资费编号
	 * @return true表示删除成功, false表示删除失败
	 */
	public boolean deleteById(int id) {
		Fee fee = findById(id); // 按id查找资费记录
		if (fee == null)
			return false; // 如果记录集中不包含该记录, 返回false 删除失败
		return recordSet.remove(fee); // 如果记录集中包含该记录, 删除成功
	}

	/**
	 * 从当前记录集中查找指定的资费记录并更新. 如果查到指定的记录则替换, 如果未找到指定的记录, 则将该资费保存到记录集
	 * 
	 * @param fee
	 *            指定的资费
	 * @return true表示更新成功, false表示更新失败
	 */
	public boolean update(Fee fee) { // 采用先删除后增加的方法来更新变量
		if (findById(fee.getId()) != null) { // 如果已经存在该记录, 删除
			deleteById(fee.getId());
		}
		return recordSet.add(fee); // 添加新的记录
	}

	/**
	 * 从当前记录集中按id查找指定的资费并返回该资费
	 * 
	 * @param id
	 *            资费编号.
	 * @return 若找到则返回找到的资费, 若未找到, 返回NULL
	 */
	public Fee findById(int id) {
		for (int i = 0; i < recordSet.size(); i++) { // 遍历记录集, 发现匹配的项就返回
			if (recordSet.get(i).getId() == id) {
				return recordSet.get(i);
			}
		}
		return null;
	}

	/**
	 * 从当前记录集中按资费名称查找指定的资费并返回查找结果. 查找的机制是优先排列按精确搜索得到的结果, 其次是按模糊搜索得到的结果
	 * 
	 * @param name
	 *            资费名称
	 * @return 返回找到的记录集合(List)
	 */
	public List<Fee> findByName(String name) {
		List<Fee> list = new ArrayList<Fee>(); // 暂时存放查询结果的集合
		for (int i = 0; i < recordSet.size(); i++) { // 遍历记录集, 发现匹配的项就放入集合中
			if (recordSet.get(i).getName().contains(name)) {
				list.add(recordSet.get(i));
			}
		}
		return list; // 检索完毕, 返回集合.
	}

	/**
	 * 从当前记录集中按资费名称查找指定的资费并按指定的排序类型返回查找结果
	 * 
	 * @param name
	 * @param ordertype
	 *            1--按资费编号排序 2--按资费名称排序 3--按基本资费排序
	 * @return 返回排序后的记录集合(List)
	 */
	public List<Fee> findByName(String name, int ordertype) {
		List<Fee> list = findByName(name); // 得到按姓名检索的集合并对该集合按指定方式排序.
		Collections.sort(list, new FeeSorter(ordertype));
		return list;
	}

	/**
	 * 从当前记录集中按基本资费的范围查找指定的资费并返回查找结果. 对查找范围的规定是:
	 * 
	 * @param begin
	 *            基本资费的范围下限
	 * @param end
	 *            基本资费的范围上限
	 * @return 返回找到的记录集合(List)
	 */
	public List<Fee> findByBaseFeeRange(double begin, double end) {
		List<Fee> list = new ArrayList<Fee>(); // 暂时存放查询结果的集合
		for (int i = 0; i < recordSet.size(); i++) { // 遍历记录集, 发现匹配的项就放入集合中
			double baseFee = recordSet.get(i).getBasefee();
			if (baseFee >= begin && baseFee < end) {
				list.add(recordSet.get(i));
			}
		}
		return list; // 检索完毕, 返回集合
	}

	/**
	 * 从当前记录集中按基本资费的范围查找指定的资费并按指定的排序类型返回查找结果
	 * 
	 * @param begin
	 *            基本资费的范围下限
	 * @param end
	 *            基本资费的范围上限
	 * @param ordertype
	 *            1--按资费编号排序 2--按资费名称排序 3--按基本资费排序
	 * @return 返回排序后的记录集合(List)
	 */
	public List<Fee> findByBaseFeeRange(double begin, double end, int ordertype) {
		List<Fee> list = this.findByBaseFeeRange(begin, end); // 得到按基本资费范围查找到的集合并对该集合按指定方式排序
		Collections.sort(list, new FeeSorter(ordertype));
		return list;
	}

	/**
	 * 返回全部的记录集
	 * 
	 * @return 所有的记录集合(List)
	 */
	public List<Fee> findAll() {
		return recordSet;
	}

	/**
	 * 按指定的排序方式返回所有的结果
	 * 
	 * @param ordertype
	 *            排序方式
	 * @return 排序后的所有记录集合(List)
	 */
	public List<Fee> findAll(int ordertype) {
		List<Fee> list = new ArrayList<Fee>(recordSet);
		Collections.sort(list, new FeeSorter(ordertype));
		return list;
	}

	/**
	 * 按资费编号对当前记录集进行排序. 该方法会影响原始记录集的排序情况
	 */
	public void orderById() {
		Collections.sort(recordSet, new FeeSorter(FeeSorter.SORT_BY_ID));
	}

	/**
	 * 按资费名称对当前记录集进行排序. 该方法会影响原始记录集的排序情况
	 */
	public void orderByName() {
		Collections.sort(recordSet, new FeeSorter(FeeSorter.SORT_BY_NAME));
	}

	/**
	 * 按基本资费对当前记录集进行排序. 该方法会影响原始记录集的排序情况
	 */
	public void orderByBaseFee() {
		Collections.sort(recordSet, new FeeSorter(FeeSorter.SORT_BY_BASEFEE));
	}

	/**
	 * 判断当前记录集是否为空
	 * 
	 * @return true表示记录集为空, false表示记录集不为空
	 */
	public boolean isEmpty() {
		return recordSet.isEmpty();
	}

	/**
	 * 得到当前记录集的大小
	 * 
	 * @return 记录集大小
	 */
	public int size() {
		return recordSet.size();
	}

	/**
	 * 以迭代方式得到当前记录集合
	 * 
	 * @return 当前记录集合(Iterator)
	 */
	public Iterator<Fee> iterator() {
		return recordSet.iterator();
	}

}
